<!--
 * @Descripttion: 
 * @version: 
 * @Author: 尹鹏孝
 * @Date: 2021-12-28 15:55:01
 * @LastEditors: 尹鹏孝
 * @LastEditTime: 2021-12-31 09:07:23
-->
<!DOCTYPE html>
<html lang="en">

<head>
    <meta charset="UTF-8">
    <meta http-equiv="X-UA-Compatible" content="IE=edge">
    <meta name="viewport" content="width=device-width, initial-scale=1.0">
    <title>递归算法的时间复杂度</title>
</head>

<body>
    <script>
        // 求x的n次方,x，n是自然数
        let result = 1;
        /* var sum = function (x, n) {
            if (x == 0) {
                return 0;
            }
            if (n === 0) {
                return 1;
            }
            if (n == 1) {
                return x;
            }
            if (x == 1) {
                return 1;
            }
            if (n === null) {
                return null;
            }
            if (x === null) {
                return null;
            }
            while (n > 0) {
                --n;
                result = result * x;
            }
            return result;
        }
        let a = sum(3, 4);
        console.log(a); */
        // 一些同学可能一看到递归就想到了$O(\log n)$，其实并不是这样，递归算法的时间复杂度本质上是要看: 递归的次数 * 每次递归中的操作次数。
        /* var sum = function (x, n) {
            if (n == 0) {
                return 1;
            }
            return sum(x, n - 1) * x;
        }
        let a = sum(8, 9);
        console.log(a); */

        function times(n) {
            for (let i = 0; i < n; i++) {
                console.log(i);//执行n次
            }
        }

        function time2(n) {
            for (let i = 0; i < n; i++) {// 执行n次
                for (let j = 0; j < n; j++) { // 执行n*n次
                    console.log(n * j * i); // 执行n*n次
                }
            }
        }

        // 表示：T(n) = O(f(n))，大O表示的是程序运行时间随着数据量变化的趋势，当n变得足够大时候，常量和系数不能决定数据大小，

        // 算法的时间复杂度计算方法
        // 1、循环次数最多方法
        function vn(n) {
            let i = 0;
            for (let j = 0; j < n; j++) {
                i = console.log(j * n);
            }
            return i;
        }
        // 2、加法原则

        function sum(d) {
            let p = 0;
            for (let k = 0; k < 1000; k++) {
                p = 20 * k;//1000
            }


            for (let k = 0; k < d; k++) {//d次
                p = d;//d
            }

        }

        // 3、乘法原则
        function md(d) {
            let result = 0;
            for (let i = 0; i < d; i++) {//d次
                for (let j = 0; j < d; j++) {//d*d次
                    result += result;//d*d次
                }
            }
        }

        // 常见的算法时间复杂度

        // O(1)
        function name(params) {
            for (let i = 0; i < 10000; i++) {
                console.log(1)
            }

            console.log('sps psp cdc');

        }

        //O(n)
        function myName(k) {
            for (let j = 0; j < k; j++) {
                console.log(k);
            }
        }

        //O(logn)，O(nlog(n)) 
        // loga(b) * logc(a) = logc(b)

        // let Func2 = function (n) {
        //     for (var i = 0; i < n; i++) {
        //         Func2(n);    //执行n次，嵌套调用，每次调用执行logn次
        //     }
        // }














    </script>

</body>

</html>